package com.yfs.cloud.util;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
* @Company: 影法師工作室
* @Description: 基于jackson 的 json 工具类, 阿里的 fastjson 安全漏洞太多~ 故弃之 
* @author 影法師  
* @date 2020年8月24日 下午4:15:50 
* @version V1.0
 */
@SuppressWarnings("all")
public class JsonUtil {

	private static Logger logger = LoggerFactory.getLogger(JsonUtil.class);

	private final static ObjectMapper objectMapper = new ObjectMapper();

	private JsonUtil() {
	}

	/**
	 * 
	* @Title: obj2json 
	* @Description: javaBean,list,array 转换为 json string
	* @param @param obj
	* @param @return    
	* @return String    
	* @throws
	 */
	public static String obj2json(Object obj) {
		try {
			return objectMapper.writeValueAsString(obj);
		} catch (JsonProcessingException e) {
			logger.error("json 解析异常  : {}", obj);
			throw new RuntimeException();
		}
	}

	/**
	 * 
	* @Title: json2pojo 
	* @Description: json string 转换为 javaBean 
	* @param @param jsonStr
	* @param @param clazz
	* @param @return    
	* @return T    
	* @throws
	 */
	public static <T> T json2pojo(String jsonStr, Class<T> clazz) {
		try {
			return objectMapper.readValue(jsonStr, clazz);
		} catch (IOException e) {
			logger.error("json 解析异常  : {}", jsonStr);
			throw new RuntimeException();
		}
	}

	/**
	 * 
	* @Title: json2map 
	* @Description: json string 转换为 map 
	* @param @param jsonStr
	* @param @return    
	* @return Map<String,Object>    
	* @throws
	 */
	public static <T> Map<String, Object> json2map(String jsonStr) {
		try {
			return objectMapper.readValue(jsonStr, Map.class);
		} catch (IOException e) {
			logger.error("json 解析异常  : {}", jsonStr);
			throw new RuntimeException();
		}
	}

	/**
	 * 
	* @Title: json2map 
	* @Description: json string 转换为 map with javaBean 
	* @param @param jsonStr
	* @param @param clazz
	* @param @return    
	* @return Map<String,T>    
	* @throws
	 */
	public static <T> Map<String, T> json2map(String jsonStr, Class<T> clazz) {
		try {
			Map<String, Map<String, Object>> map = objectMapper.readValue(jsonStr, new TypeReference<Map<String, T>>() {
			});
			Map<String, T> result = new HashMap<String, T>();
			for (Entry<String, Map<String, Object>> entry : map.entrySet()) {
				result.put(entry.getKey(), map2pojo(entry.getValue(), clazz));
			}
			return result;
		} catch (IOException e) {
			logger.error("json 解析异常  : {}", jsonStr);
			throw new RuntimeException();
		}
	}

	/**
	 * 
	* @Title: json2list 
	* @Description: json array string 转换为 list with javaBean 
	* @param @param jsonArrayStr
	* @param @param clazz
	* @param @return    
	* @return List<T>    
	* @throws
	 */
	public static <T> List<T> json2list(String jsonArrayStr, Class<T> clazz) {
		try {
			List<Map<String, Object>> list = objectMapper.readValue(jsonArrayStr, new TypeReference<List<T>>() {
			});
			List<T> result = new ArrayList<T>();
			for (Map<String, Object> map : list) {
				result.add(map2pojo(map, clazz));
			}
			return result;
		} catch (IOException e) {
			logger.error("json 解析异常  : {}", jsonArrayStr);
			throw new RuntimeException();
		}
	}

	/**
	 * 
	* @Title: map2pojo 
	* @Description: map 转换为 javaBean 
	* @param @param map
	* @param @param clazz
	* @param @return    
	* @return T    
	* @throws
	 */
	public static <T> T map2pojo(Map map, Class<T> clazz) {
		return objectMapper.convertValue(map, clazz);
	}

	/**
	* @Description: feign接口调用统一返回的是形如 {code: , msg: data: } 的json 字符串, 现在要将 data 对象解析为对象
	* @author 影法師
	* @date 2020年8月27日 上午10:23:05 
	* @version V1.0 
	* @param @param json
	* @param @return    
	* @return T    
	* @throws
	 */
	public static <T> T feignResult2Object(String resultJson, Class<T> clazz) {
		// 总的树节点
		JsonNode result = null;
		try {
			result = objectMapper.readTree(resultJson);
		} catch (IOException e) {
			logger.error("json 解析异常  : {}", resultJson);
			throw new RuntimeException();
		}
		// data 节点
		JsonNode data = result.get("data");
		// data 节点的json 字符串
		String dataJsonStr = data.toString();
		return json2pojo(dataJsonStr, clazz);
	}

	/**json对象字符串开始标记*/
	final static String JSON_OBJECT_START = "{";

	/**json对象字符串结束标记*/
	final static String JSON_OBJECT_END = "}";

	/**json数组字符串开始标记*/
	final static String JSON_ARRAY_START = "[";

	/**json数组字符串结束标记*/
	final static String JSON_ARRAY_END = "]";

	/**
	* @Description: 判断字符串是否是json对象字符串
	* @author 影法師 
	* @date 2020年8月28日 下午2:09:44 
	* @version V1.0 
	* @param @param json 待判断的字符串
	* @param @return    
	* @return boolean    
	* @throws
	 */
	public static boolean isJsonObj(String json) {
		if (StringUtils.isBlank(json)) { // isBlank 对于 " " 这种也是判定为空的, 这是 isBlank 和 isEmpty 的区别, 所以一般推荐使用 isBlank 而不是
											// isEmpty
			return false;
		}
		json = json.trim();
		if (json.startsWith(JSON_OBJECT_START) && json.endsWith(JSON_OBJECT_END)) {
			try {
				objectMapper.readTree(json);
				return true;
			} catch (Exception e) {
				return false;
			}
		}
		return false;
	}

	/**
	* @Description: 判断字符串是否json数组字符串
	* @author 影法師 
	* @date 2020年8月28日 下午2:10:11 
	* @version V1.0 
	* @param @param json 待判断的字符串
	* @param @return    
	* @return boolean    
	* @throws
	 */
	public static boolean isJsonArr(String json) {
		if (StringUtils.isBlank(json)) {
			return false;
		}
		json = json.trim();
		if (json.startsWith(JSON_ARRAY_START) && json.endsWith(JSON_ARRAY_END)) {
			try {
				objectMapper.readValue(json, new TypeReference<List<?>>() {
				});
				return true;
			} catch (Exception e) {
				return false;
			}
		}
		return false;
	}

}